import argparse
import os
import timeit

import byteps.tensorflow as bps
import numpy as np
import tensorflow as tf
from tensorflow.keras import applications

# Benchmark settings
parser = argparse.ArgumentParser(
    description="TensorFlow Synthetic Benchmark",
    formatter_class=argparse.ArgumentDefaultsHelpFormatter,
)
parser.add_argument(
    "--fp16-allreduce",
    action="store_true",
    default=False,
    help="use fp16 compression during allreduce",
)

parser.add_argument("--model", type=str, default="ResNet50", help="model to benchmark")
parser.add_argument("--batch-size", type=int, default=32, help="input batch size")

parser.add_argument(
    "--num-warmup-batches",
    type=int,
    default=10,
    help="number of warm-up batches that don't count towards benchmark",
)
parser.add_argument(
    "--num-batches-per-iter",
    type=int,
    default=10,
    help="number of batches per benchmark iteration",
)
parser.add_argument(
    "--num-iters", type=int, default=10, help="number of benchmark iterations"
)

parser.add_argument(
    "--no-cuda", action="store_true", default=False, help="disables CUDA training"
)

args = parser.parse_args()
args.cuda = not args.no_cuda

bps.init()

# pin GPU to be used to process local rank (one GPU per process)
if args.cuda:
    gpus = tf.config.experimental.list_physical_devices("GPU")
    for gpu in gpus:
        tf.config.experimental.set_memory_growth(gpu, True)
    if gpus:
        tf.config.experimental.set_visible_devices(gpus[bps.local_rank()], "GPU")
else:
    os.environ["CUDA_VISIBLE_DEVICES"] = "-1"

# Set up standard model.
model = getattr(applications, args.model)(weights=None)
opt = tf.optimizers.SGD(0.01)

data = tf.random.uniform([args.batch_size, 224, 224, 3])
target = tf.random.uniform([args.batch_size, 1], minval=0, maxval=999, dtype=tf.int64)


@tf.function
def benchmark_step(first_batch):
    # BytePS: (optional) compression algorithm.
    compression = bps.Compression.fp16 if args.fp16_allreduce else bps.Compression.none

    # BytePS: use DistributedGradientTape
    with tf.GradientTape() as tape:
        probs = model(data, training=True)
        loss = tf.losses.categorical_crossentropy(target, probs)

    # BytePS: add bps Distributed GradientTape.
    tape = bps.DistributedGradientTape(tape, compression=compression)

    gradients = tape.gradient(loss, model.trainable_variables)
    opt.apply_gradients(zip(gradients, model.trainable_variables))

    # Broadcast initial variable states from rank 0 to all other processes.
    # This is necessary to ensure consistent initialization of all workers when
    # training is started with random weights or restored from a checkpoint.
    #
    # Note: broadcast should be done after the first gradient step to ensure optimizer
    # initialization.
    if first_batch:
        bps.broadcast_variables(model.variables, root_rank=0)
        bps.broadcast_variables(opt.variables(), root_rank=0)


def log(s, nl=True):
    if bps.rank() != 0:
        return
    print(s, end="\n" if nl else "")


log("Model: %s" % args.model)
log("Batch size: %d" % args.batch_size)
device = "GPU" if args.cuda else "CPU"
log("Number of %ss: %d" % (device, bps.size()))


with tf.device(device):
    # Warm-up
    log("Running warmup...")
    benchmark_step(first_batch=True)
    timeit.timeit(
        lambda: benchmark_step(first_batch=False), number=args.num_warmup_batches
    )

    # Benchmark
    log("Running benchmark...")
    img_secs = []
    for x in range(args.num_iters):
        time = timeit.timeit(
            lambda: benchmark_step(first_batch=False), number=args.num_batches_per_iter
        )
        img_sec = args.batch_size * args.num_batches_per_iter / time
        log("Iter #%d: %.1f img/sec per %s" % (x, img_sec, device))
        img_secs.append(img_sec)

    # Results
    img_sec_mean = np.mean(img_secs)
    img_sec_conf = 1.96 * np.std(img_secs)
    log(f"Img/sec per {device}: {img_sec_mean:.1f} +-{img_sec_conf:.1f}")
    log(
        "Total img/sec on %d %s(s): %.1f +-%.1f"
        % (bps.size(), device, bps.size() * img_sec_mean, bps.size() * img_sec_conf)
    )
